{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "  \"\"\"\n",
    "  Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "  it for the linear classifier. These are the same steps as we used for the\n",
    "  SVM, but condensed to a single function.  \n",
    "  \"\"\"\n",
    "  # Load the raw CIFAR-10 data\n",
    "  cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "  X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "  \n",
    "  # subsample the data\n",
    "  mask = range(num_training, num_training + num_validation)\n",
    "  X_val = X_train[mask]\n",
    "  y_val = y_train[mask]\n",
    "  mask = range(num_training)\n",
    "  X_train = X_train[mask]\n",
    "  y_train = y_train[mask]\n",
    "  mask = range(num_test)\n",
    "  X_test = X_test[mask]\n",
    "  y_test = y_test[mask]\n",
    "  mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "  X_dev = X_train[mask]\n",
    "  y_dev = y_train[mask]\n",
    "  \n",
    "  # Preprocessing: reshape the image data into rows\n",
    "  X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "  X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "  X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "  X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "  \n",
    "  # Normalize the data: subtract the mean image\n",
    "  mean_image = np.mean(X_train, axis = 0)\n",
    "  X_train -= mean_image\n",
    "  X_val -= mean_image\n",
    "  X_test -= mean_image\n",
    "  X_dev -= mean_image\n",
    "  \n",
    "  # add bias dimension and transform into columns\n",
    "  X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "  X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "  X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "  X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "  \n",
    "  return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print ('Train data shape: ', X_train.shape)\n",
    "print ('Train labels shape: ', y_train.shape)\n",
    "print ('Validation data shape: ', X_val.shape)\n",
    "print ('Validation labels shape: ', y_val.shape)\n",
    "print ('Test data shape: ', X_test.shape)\n",
    "print ('Test labels shape: ', y_test.shape)\n",
    "print ('dev data shape: ', X_dev.shape)\n",
    "print ('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.393936\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print ('loss: %f' % loss)\n",
    "print ('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "**Your answer:** *Fill this in*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -1.340124 analytic: -1.340124, relative error: 1.639247e-08\n",
      "numerical: 1.523803 analytic: 1.523803, relative error: 3.575887e-08\n",
      "numerical: 2.095556 analytic: 2.095556, relative error: 3.646730e-08\n",
      "numerical: 5.960210 analytic: 5.960210, relative error: 1.930508e-08\n",
      "numerical: -1.753363 analytic: -1.753363, relative error: 4.628697e-08\n",
      "numerical: 0.670833 analytic: 0.670833, relative error: 2.545691e-08\n",
      "numerical: 1.209116 analytic: 1.209116, relative error: 5.738864e-08\n",
      "numerical: 0.079224 analytic: 0.079224, relative error: 4.390380e-07\n",
      "numerical: -3.396154 analytic: -3.396154, relative error: 1.632339e-08\n",
      "numerical: -3.226055 analytic: -3.226054, relative error: 1.454415e-08\n",
      "numerical: 2.233676 analytic: 2.233676, relative error: 2.353399e-08\n",
      "numerical: 0.071229 analytic: 0.071229, relative error: 9.735287e-08\n",
      "numerical: -1.740578 analytic: -1.740578, relative error: 5.598592e-10\n",
      "numerical: -3.396687 analytic: -3.396687, relative error: 2.194933e-08\n",
      "numerical: 1.254076 analytic: 1.254076, relative error: 7.519058e-09\n",
      "numerical: 1.697161 analytic: 1.697161, relative error: 2.594101e-08\n",
      "numerical: 0.038367 analytic: 0.038367, relative error: 2.308883e-06\n",
      "numerical: 2.645159 analytic: 2.645159, relative error: 1.307730e-08\n",
      "numerical: -3.619284 analytic: -3.619284, relative error: 7.821515e-09\n",
      "numerical: -1.531733 analytic: -1.531733, relative error: 2.413001e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 1e2)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 1e2)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.393936e+00 computed in 0.173535s\n",
      "vectorized loss: 2.393936e+00 computed in 0.003992s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.00001)\n",
    "toc = time.time()\n",
    "print ('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.00001)\n",
    "toc = time.time()\n",
    "print ('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print ('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print ('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 2000: loss 386.657524\n",
      "iteration 100 / 2000: loss 233.611102\n",
      "iteration 200 / 2000: loss 141.869320\n",
      "iteration 300 / 2000: loss 86.463303\n",
      "iteration 400 / 2000: loss 53.185566\n",
      "iteration 500 / 2000: loss 32.957778\n",
      "iteration 600 / 2000: loss 20.701541\n",
      "iteration 700 / 2000: loss 13.280697\n",
      "iteration 800 / 2000: loss 8.896483\n",
      "iteration 900 / 2000: loss 6.135764\n",
      "iteration 1000 / 2000: loss 4.513549\n",
      "iteration 1100 / 2000: loss 3.587306\n",
      "iteration 1200 / 2000: loss 2.953290\n",
      "iteration 1300 / 2000: loss 2.607789\n",
      "iteration 1400 / 2000: loss 2.283962\n",
      "iteration 1500 / 2000: loss 2.180577\n",
      "iteration 1600 / 2000: loss 2.150197\n",
      "iteration 1700 / 2000: loss 2.163561\n",
      "iteration 1800 / 2000: loss 2.071372\n",
      "iteration 1900 / 2000: loss 2.040395\n",
      "iteration 0 / 2000: loss 767.932539\n",
      "iteration 100 / 2000: loss 282.011119\n",
      "iteration 200 / 2000: loss 104.333574\n",
      "iteration 300 / 2000: loss 39.631418\n",
      "iteration 400 / 2000: loss 15.902849\n",
      "iteration 500 / 2000: loss 7.086362\n",
      "iteration 600 / 2000: loss 3.967460\n",
      "iteration 700 / 2000: loss 2.778191\n",
      "iteration 800 / 2000: loss 2.331037\n",
      "iteration 900 / 2000: loss 2.142843\n",
      "iteration 1000 / 2000: loss 2.110166\n",
      "iteration 1100 / 2000: loss 2.065448\n",
      "iteration 1200 / 2000: loss 2.123037\n",
      "iteration 1300 / 2000: loss 2.111678\n",
      "iteration 1400 / 2000: loss 2.080793\n",
      "iteration 1500 / 2000: loss 2.047919\n",
      "iteration 1600 / 2000: loss 2.117185\n",
      "iteration 1700 / 2000: loss 2.108711\n",
      "iteration 1800 / 2000: loss 2.122114\n",
      "iteration 1900 / 2000: loss 2.104284\n",
      "iteration 0 / 2000: loss 392.093316\n",
      "iteration 100 / 2000: loss 33.038849\n",
      "iteration 200 / 2000: loss 4.553377\n",
      "iteration 300 / 2000: loss 2.202348\n",
      "iteration 400 / 2000: loss 2.022782\n",
      "iteration 500 / 2000: loss 1.989769\n",
      "iteration 600 / 2000: loss 1.998234\n",
      "iteration 700 / 2000: loss 2.014202\n",
      "iteration 800 / 2000: loss 2.088938\n",
      "iteration 900 / 2000: loss 2.028130\n",
      "iteration 1000 / 2000: loss 1.992531\n",
      "iteration 1100 / 2000: loss 2.038179\n",
      "iteration 1200 / 2000: loss 1.982421\n",
      "iteration 1300 / 2000: loss 2.023655\n",
      "iteration 1400 / 2000: loss 1.995963\n",
      "iteration 1500 / 2000: loss 2.018402\n",
      "iteration 1600 / 2000: loss 2.085127\n",
      "iteration 1700 / 2000: loss 2.090476\n",
      "iteration 1800 / 2000: loss 2.054024\n",
      "iteration 1900 / 2000: loss 2.043220\n",
      "iteration 0 / 2000: loss 768.402629\n",
      "iteration 100 / 2000: loss 6.809591\n",
      "iteration 200 / 2000: loss 2.164305\n",
      "iteration 300 / 2000: loss 2.124970\n",
      "iteration 400 / 2000: loss 2.132963\n",
      "iteration 500 / 2000: loss 2.103811\n",
      "iteration 600 / 2000: loss 2.085010\n",
      "iteration 700 / 2000: loss 2.133454\n",
      "iteration 800 / 2000: loss 2.084116\n",
      "iteration 900 / 2000: loss 2.120228\n",
      "iteration 1000 / 2000: loss 2.107407\n",
      "iteration 1100 / 2000: loss 2.108874\n",
      "iteration 1200 / 2000: loss 2.064082\n",
      "iteration 1300 / 2000: loss 2.035279\n",
      "iteration 1400 / 2000: loss 2.053397\n",
      "iteration 1500 / 2000: loss 2.116819\n",
      "iteration 1600 / 2000: loss 2.060774\n",
      "iteration 1700 / 2000: loss 2.099847\n",
      "iteration 1800 / 2000: loss 2.094823\n",
      "iteration 1900 / 2000: loss 2.145300\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.348796 val accuracy: 0.366000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.331714 val accuracy: 0.350000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.349000 val accuracy: 0.367000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.324327 val accuracy: 0.343000\n",
      "best validation accuracy achieved during cross-validation: 0.367000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax=Softmax();\n",
    "        softmax.train(X_train,y_train,lr,reg,num_iters=2000,batch_size=200,\\\n",
    "                     verbose=True)\n",
    "        YTrainPred=softmax.predict(X_train)\n",
    "        train_accuracy=np.mean(YTrainPred==y_train)\n",
    "        YValPred=softmax.predict(X_val)\n",
    "        val_accuracy=np.mean(YValPred==y_val)\n",
    "        results[(lr,reg)]=(train_accuracy,val_accuracy)\n",
    "        if val_accuracy>best_val:\n",
    "            best_val=val_accuracy\n",
    "            best_softmax=softmax\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print ('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print ('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.355000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print ('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "  plt.subplot(2, 5, i + 1)\n",
    "  \n",
    "  # Rescale the weights to be between 0 and 255\n",
    "  wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "  plt.imshow(wimg.astype('uint8'))\n",
    "  plt.axis('off')\n",
    "  plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
